package com.aps.orchestrator.scenario;

import com.aps.common.model.APSProductModel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * 生产场景分析器
 * 负责分析APS产品模型，提取生产场景特征
 */
@Slf4j
@Component
public class ScenarioAnalyzer {
    
    /**
     * 分析生产场景
     * @param model APS产品模型
     * @return 生产场景
     */
    public ProductionScenario analyzeScenario(APSProductModel model) {
        log.info("开始分析生产场景");
        
        // 统计基本信息
        int orderCount = model.getOrders() != null ? model.getOrders().size() : 0;
        int operationCount = model.getOperations() != null ? model.getOperations().size() : 0;
        int resourceCount = calculateResourceCount(model);
        int constraintCount = calculateConstraintCount(model);
        
        // 分析生产规模
        ProductionScenario.ProductionScale scale = ProductionScenario.ProductionScale.fromOrderCount(orderCount);
        
        // 分析生产复杂度
        ProductionScenario.ProductionComplexity complexity = 
            ProductionScenario.ProductionComplexity.fromOperationCount(operationCount);
        
        // 分析动态性级别（这里使用默认值，实际应该根据历史数据或配置分析）
        ProductionScenario.DynamicLevel dynamicLevel = analyzeDynamicLevel(model);
        
        // 分析是否为多目标优化
        boolean multiObjective = analyzeMultiObjective(model);
        
        // 分析是否为实时排程
        boolean realTime = analyzeRealTime(model);
        
        // 生成场景描述
        String description = generateDescription(scale, complexity, dynamicLevel, orderCount, operationCount);
        
        ProductionScenario scenario = ProductionScenario.builder()
            .scale(scale)
            .complexity(complexity)
            .dynamicLevel(dynamicLevel)
            .orderCount(orderCount)
            .operationCount(operationCount)
            .resourceCount(resourceCount)
            .constraintCount(constraintCount)
            .multiObjective(multiObjective)
            .realTime(realTime)
            .description(description)
            .build();
        
        log.info("生产场景分析完成: {}", scenario);
        
        return scenario;
    }
    
    /**
     * 计算资源数量
     * @param model APS产品模型
     * @return 资源数量
     */
    private int calculateResourceCount(APSProductModel model) {
        int count = 0;
        
        if (model.getResources() != null) {
            if (model.getResources().getEquipment() != null) {
                count += model.getResources().getEquipment().size();
            }
            if (model.getResources().getPersonnel() != null) {
                count += model.getResources().getPersonnel().size();
            }
        }
        
        return count;
    }
    
    /**
     * 计算约束数量
     * @param model APS产品模型
     * @return 约束数量
     */
    private int calculateConstraintCount(APSProductModel model) {
        int count = 0;
        
        if (model.getConstraints() != null) {
            if (model.getConstraints().getHardConstraints() != null) {
                count += model.getConstraints().getHardConstraints().size();
            }
            if (model.getConstraints().getSoftConstraints() != null) {
                count += model.getConstraints().getSoftConstraints().size();
            }
        }
        
        return count;
    }
    
    /**
     * 分析动态性级别
     * @param model APS产品模型
     * @return 动态性级别
     */
    private ProductionScenario.DynamicLevel analyzeDynamicLevel(APSProductModel model) {
        // 这里可以根据订单的交期分布、优先级分布等来判断动态性
        // 暂时使用默认的中等动态级别
        return ProductionScenario.DynamicLevel.MEDIUM;
    }
    
    /**
     * 分析是否为多目标优化
     * @param model APS产品模型
     * @return 是否为多目标优化
     */
    private boolean analyzeMultiObjective(APSProductModel model) {
        // 检查是否有多个软约束，如果有多个软约束，通常意味着多目标优化
        if (model.getConstraints() != null && model.getConstraints().getSoftConstraints() != null) {
            return model.getConstraints().getSoftConstraints().size() > 1;
        }
        return false;
    }
    
    /**
     * 分析是否为实时排程
     * @param model APS产品模型
     * @return 是否为实时排程
     */
    private boolean analyzeRealTime(APSProductModel model) {
        // 检查是否有紧急订单（交期很近的订单）
        if (model.getOrders() != null) {
            return model.getOrders().stream()
                .anyMatch(order -> {
                    // 检查是否有交期在3天内的订单
                    try {
                        java.time.LocalDate deliveryDate = java.time.LocalDate.parse(order.getDeliveryDate());
                        java.time.LocalDate currentDate = java.time.LocalDate.now();
                        long daysToDelivery = java.time.temporal.ChronoUnit.DAYS.between(currentDate, deliveryDate);
                        return daysToDelivery <= 3;
                    } catch (Exception e) {
                        return false;
                    }
                });
        }
        return false;
    }
    
    /**
     * 生成场景描述
     * @param scale 生产规模
     * @param complexity 生产复杂度
     * @param dynamicLevel 动态性级别
     * @param orderCount 订单数量
     * @param operationCount 工序数量
     * @return 场景描述
     */
    private String generateDescription(ProductionScenario.ProductionScale scale,
                                     ProductionScenario.ProductionComplexity complexity,
                                     ProductionScenario.DynamicLevel dynamicLevel,
                                     int orderCount,
                                     int operationCount) {
        
        return String.format("%s%s%s生产场景，包含%d个订单，%d个工序",
            scale.getDescription(),
            complexity.getDescription(),
            dynamicLevel.getDescription(),
            orderCount,
            operationCount);
    }
}
